/* Universidad del Valle de Guatemala
 * CC2003 - Algoritmos y Estructuras de Datos
 * PROYECTO #1: RURPLE ME
 * Fecha de Entrega: Jueves 11 de Agosto de 2011
 */

/**
 * Clase permite la creacion del Robot en los Mapas de la aplicacion, define sus caracteristicas y movimientos.
 * @author José Antonio Bagur (10275), Luis Antonio Siguenza (10297) y Emilo José Miranda (10411).
 */

/* SE CARGAN LOS PAQUETES A UTILIZAR EN LA CLASE */
import javax.microedition.lcdui.*;

/* SE HEREDAN LOS MÉTODOS Y ATRIBUTOS DEL PAQUETE CANVAS */
public class RobotRurple extends Canvas {

     /* ATRIBUTOS DE LA CLASE ROBOTRURPLE */
    
    private int posx;
    private int posy;
    private int orden;
    protected int anteriorx;
    protected int anteriory;
    private int[][] paredes;
    protected boolean gano;
    protected boolean error;
    protected boolean perdio;
    protected String codigo_mapa;
    protected String codigo_script;
    boolean prueba;

    /* MÉTODOS DE LA CLASE ROBOTRURPLE */
    
    /**
     * Constructor de la clase RobotRurple; inicializa las caracteristicas del Robot. 
     */
    public RobotRurple() {
        posx = 171;
        posy = 201; 
        anteriorx = 171;
        anteriory = 201;
        orden = 0;
        codigo_mapa = "";
        codigo_script = "";
        error = false;
        gano = false;
        perdio = false;
        paredes = new int[99][2];   
    }

    /**
     * Metodo que permite generar un mapa de juego a partir de la información almacenada por el usuario.
     * @param codigo especificaciones del mapa.
     */
    public void generarMapa(String codigo) {
        codigo_mapa = codigo;
    }
    /**
     * Metodo que permite generar un script a partir de la informacion almacenada por el usuario.
     * @param codigo especificaciones del script.
     */
    public void generarScript(String codigo) {
        codigo_script = codigo;
        
        char caracter = ' ';        
        for (int i = 0; i < codigo_script.length(); i++) {
            caracter = codigo_script.charAt(i);
            if (caracter != '2' && caracter != '4' && caracter != '6' && caracter != '8') {
                error = true;
            }
        }
    }

    /**
     * Metodo que permite la creacion de la pantalla de juego en la aplicacion.
     * @param g graficos. 
     */ 
    public void paint(Graphics g) {
        Image imagen = null;
        char codigo = ' ';
        int fil = 0;
        
        /* PINTAR PANTALLA DE NEGRO */
        g.setColor(0, 0, 0);
        g.fillRect(0, 0, getWidth(), getHeight());
        
        /* ¿EXISTE UN ERROR AL CARGAR UNA IMAGEN */
        if (error) {
            
            try {
                imagen = Image.createImage("/error.png");
                prueba = true;
            } catch (Exception e) {
                System.err.println("ERROR: " + e);
            }
            g.drawImage(imagen, 0, 0, 0);
        }
        
        /* EL USUARIO HA GANADO UNA PARTIDA */
        if (gano) {
            
            try {
                imagen = Image.createImage("/gano.png");
            } catch (Exception e) {
                System.err.println("ERROR: " + e);
            }
            g.drawImage(imagen, 0, 0, 0);
        }
        
        /* EL USUARIO HA PERDIDO UNA PARTIDA */
        if (perdio) {
            
            try {
                imagen = Image.createImage("/perdio.png");
            } catch (Exception e) {
                System.err.println("ERROR: " + e);
            }
            g.drawImage(imagen, 0, 0, 0);
        }
        
        /* CREACIÓN DE LA CUADRÍCULA (DIBUJAR CUADROS VERDES) */
        for (int j = 30; j < 220; j += 19) {
            for (int i = 0; i < 190; i += 19) {
                
                try {
                    imagen = Image.createImage("/Grama.jpg");
                } catch (Exception e) {
                    System.err.println("ERROR: " + e);
                }
                g.drawImage(imagen, i, j, 0);
            }
        }        
        
        /* COLOCAR OBJETIVO DEL ROBOT (ESQUINA SUPERIOR IZQUIERDA) */
        try {
            imagen = Image.createImage("/Objetivo.png");
        } catch (Exception e) {
            System.err.println("ERROR: " + e);
        }
        g.drawImage(imagen, 0, 30, 0);
        
        /* INICIALIZAR POSICIÓN DEL ROBOT (ESQUINA INFERIOR DERECHA) */
        try {
            imagen = Image.createImage("/Robot.png");
        } catch (Exception e) {
            System.err.println("ERROR: " + e);
        }
        g.drawImage(imagen, posx, posy, 0);

        int pos = 0;        
        if (codigo_mapa.length() <= 99) {            
            for (int j = 30; j < 220; j += 19) {                
                for (int i = 0; i < 190; i += 19) {   
                    
                    try {
                        codigo = codigo_mapa.charAt(pos);
                    } catch (Exception e) {}
                    
                    
                    /* EXCLUIR OBJETIVO DEL ROBOT */
                    if (j == 30) {
                        if (i == 0) {                            
                            i = 19;
                        }
                    }
                    
                    /* GENERAR MAPA A PARTIR DE LA INFORMACIÓN ALMACENADA */
                    switch (codigo) {
                        case '1':
                            try {
                                imagen = Image.createImage("/Piedra.png");        
                            } catch (Exception e) {
                                System.err.println("ERROR: " + e);
                            }
                            g.drawImage(imagen, i, j, 0);  
                            
                            paredes[fil][0] = i;
                            paredes[fil][1] = j;
                            fil++;                            
                            break;                                            
                        default:
                            if (codigo != '0') {
                                error = true;
                                repaint();                            
                            }
                            break;
                    }
                    pos++;
                }
            }
        } else {
            error = true;
            repaint();
        }
    }
    
    /**
     * Metodo que permite mover al Robot durante la ejecucion de scripts. 
     * @param pos posicion actual del Robot en el Mapa.
     */
    public void moverRurple(int pos) {
        char codigo = ' ';
        anteriorx = posx;
        anteriory = posy;        
        
        /* DESIGNAR UN MOVIMIENTO AL ROBOT */
        if (codigo_script.length() > 0) {
            try {
                codigo = codigo_script.charAt(pos);
            } catch (Exception e) {}
                                    
            switch(codigo) {
                case '2':
                    if (posy > 30) {
                        posy -= 19;
                    }
                    break;
                case '4':
                    if (posx > 0) {
                        posx -= 19;
                    }                    
                    break;
                case '6':
                    if (posx < 171) {
                        posx += 19;
                    }                      
                    break;
                case '8':
                    if (posy < 201) {
                        posy += 19;
                    }                    
                    break;
                default:
                    error = true;
            }
            
            /* REVISAR QUE EL ROBOT PUEDA MOVERSE */
            for (int i = 0; i < paredes.length; i++) {
                if (posx == paredes[i][0]) {
                    if (posy == paredes[i][1]) {
                        posx = anteriorx;
                        posy = anteriory;
                    }                    
                }
            }                 
            repaint();
        }  
    }
    
    /**
     * Metodo que permite obtener el proximo movimiento que realizara el Robot durante la ejecucion de un script.
     */
    public void siguienteMovimiento() {           
        if (error == false) {
            moverRurple(orden);
            orden++; 
        }
        
        if (orden == codigo_script.length()) {
            if (posx == 0 && posy == 30) {
                gano = true;
                repaint();
            } else {
                perdio = true;
                repaint();
            }            
        }
    }   
} // FIN DE LA CLASE ROBOTRURPLE